package java8.lombda;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
 * @author 周宇
 * @create 2020-05-19 14:22
 */
public class LambdaCore {

    /**
     * 1.消费型接口（无返回值，有去无回）
     * ()可以省略!
     * aaa!
     * bbb!
     * ccc!
     */
    public void ConsumerTest(Consumer<String> consumer) {
        //forEach方法需要的就是一个Consumer接口
        Stream<String> stream = Stream.of("aaa", "bbb", "ccc");
        stream.forEach(consumer);
    }

    /**
     * 2.供给型接口 大多用于创建对象
     */
    //需求：产生指定个数的整数，并放入集合中
    public List<Integer> SupplierTest(int num, Supplier<Integer> sup) {
        Supplier<ArrayList> arrayList = ArrayList::new;
        ArrayList list = arrayList.get();//创建ArrayList

        for (int i = 0; i < num; i++) {
            Integer n = sup.get();//创建Integer
            list.add(n);
        }
        return list;
    }

    /**
     * 3.函数型接口 Function
     * 换个名字 加一个title
     */
    public String FunctionTest(String name, Function<String, String> function) {
        return function.apply(name);
    }

    /**
     * 4.断言型接口
     *
     * @param age 年龄
     * @return 1-120之间合法返回true
     */
    public boolean PredicateTest(Integer age, Predicate<Integer> predicate) {
        return predicate.test(age);
    }

    public static void main(String[] args) {
        LambdaCore core = new LambdaCore();
        //Consumer 接受一个T类型的参数，无返回。
        Consumer<String> consumer = str -> System.out.println(str + "!");
        consumer.accept("()可以省略");
        core.ConsumerTest(consumer);

        //Supplier 无输入参数，返回T类型的一个结果。
        Supplier<Integer> sup = () -> {
            return new Integer(0);
        };
        List<Integer> numList = core.SupplierTest(3, sup);
        System.out.println(numList);//[0, 0, 0]

        //Function 接受一个T类型的参数，返回R类型结果。
        Function function = name -> name + "最棒！";
        String xiaoming = core.FunctionTest("小明", function);
        System.out.println(xiaoming);

        //Predicate 接受一个T类型的参数，返回布尔值。
        Predicate<Integer> predicate = (Integer integer) -> {
            if (integer > 1 && integer <= 120) return true;
            return false;
        };
        boolean age1 = core.PredicateTest(18, predicate);
        boolean age2 = core.PredicateTest(121, predicate);
        System.out.println(age1);
        System.out.println(age2);
    }
}
